# Copyright 2024 Bytedance Ltd. and/or its affiliates
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Copyright 2025 Pokee AI Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


# This file is based on verl/verl/trainer/main_ppo.py. But we only keep the testing logic here.

import os
import signal
import socket
import sys

import hydra
import ray
from omegaconf import OmegaConf

from ray_test import RayTest
from verl.trainer.constants_ppo import get_ppo_ray_runtime_env
from verl.trainer.ppo.reward import load_reward_manager
from verl.utils.device import is_cuda_available
from verl.utils.import_utils import load_extern_type


def signal_handler(signum, frame):
    """Handle SIGTERM and SIGINT signals gracefully."""
    print(f"Received signal {signum}. Shutting down Ray gracefully...")
    try:
        if ray.is_initialized():
            ray.shutdown()
            print("Ray cluster shutdown successfully")
    except Exception as e:
        print(f"Warning: Error during Ray shutdown: {e}")
    sys.exit(0)


# Register signal handlers
signal.signal(signal.SIGTERM, signal_handler)
signal.signal(signal.SIGINT, signal_handler)


@hydra.main(config_path="config", config_name="ppo_trainer", version_base=None)
def main(config):
    """Main entry point for PPO training with Hydra configuration management.

    Args:
        config_dict: Hydra configuration dictionary containing training parameters.
    """
    run_ppo(config)


# Define a function to run the PPO-like training process
def run_ppo(config) -> None:
    """Initialize Ray cluster and run distributed PPO training process.

    Args:
        config: Testing configuration object containing all necessary parameters
                for distributed testing including Ray initialization settings,
                model paths, and testing hyperparameters.
    """
    ray_initialized_here = False
    try:
        # Check if Ray is not initialized
        if not ray.is_initialized():
            ray_initialized_here = True
            # Initialize Ray with a local cluster configuration
            # Set environment variables in the runtime environment to control tokenizer parallelism,
            # NCCL debug level, VLLM logging level, and allow runtime LoRA updating
            # `num_cpus` specifies the number of CPU cores Ray can use, obtained from the configuration
            default_runtime_env = get_ppo_ray_runtime_env()
            ray_init_kwargs = config.ray_kwargs.get("ray_init", {})
            runtime_env_kwargs = ray_init_kwargs.get("runtime_env", {})
            runtime_env = OmegaConf.merge(default_runtime_env, runtime_env_kwargs)
            ray_init_kwargs = OmegaConf.create(
                {**ray_init_kwargs, "runtime_env": runtime_env}
            )
            print(f"ray init kwargs: {ray_init_kwargs}")
            ray.init(**OmegaConf.to_container(ray_init_kwargs))

        # Create a remote instance of the TaskRunner class, and
        # Execute the `run` method of the TaskRunner instance remotely and wait for it to complete
        if (
            is_cuda_available
            and config.global_profiler.tool == "nsys"
            and config.global_profiler.get("steps") is not None
            and len(config.global_profiler.get("steps", [])) > 0
        ):
            from verl.utils.import_utils import is_nvtx_available

            assert is_nvtx_available(), (
                "nvtx is not available in CUDA platform. Please 'pip3 install nvtx'"
            )
            nsight_options = OmegaConf.to_container(
                config.global_profiler.global_tool_config.nsys.controller_nsight_options
            )
            runner = TaskRunner.options(runtime_env={"nsight": nsight_options}).remote()
        else:
            runner = TaskRunner.remote()
        ray.get(runner.run.remote(config))

        # [Optional] get the path of the timeline trace file from the configuration, default to None
        # This file is used for performance analysis
        timeline_json_file = config.ray_kwargs.get("timeline_json_file", None)
        if timeline_json_file:
            ray.timeline(filename=timeline_json_file)
    
    except Exception as e:
        print(f"Error during testing: {e}")
        raise e
    
    finally:
        # Properly shutdown Ray to prevent worker crashes
        if ray_initialized_here and ray.is_initialized():
            try:
                ray.shutdown()
                print("Ray cluster shutdown successfully")
            except Exception as e:
                print(f"Warning: Error during Ray shutdown: {e}")


@ray.remote(num_cpus=1)  # please make sure main_task is not scheduled on head
class TaskRunner:
    """Ray remote class for executing distributed testing tasks.

    This class encapsulates the main testing logic and runs as a Ray remote actor
    to enable distributed execution across multiple nodes and GPUs.

    Attributes:
        role_worker_mapping: Dictionary mapping Role enums to Ray remote worker classes
        mapping: Dictionary mapping Role enums to resource pool IDs for GPU allocation
    """

    def __init__(self):
        self.role_worker_mapping = {}
        self.mapping = {}

    def add_actor_rollout_worker(self, config):
        """Add actor rollout worker based on the actor strategy."""
        from verl.single_controller.ray import RayWorkerGroup

        if config.actor_rollout_ref.actor.strategy in {"fsdp", "fsdp2"}:
            from verl.workers.fsdp_workers import (
                ActorRolloutRefWorker,
                AsyncActorRolloutRefWorker,
            )

            actor_rollout_cls = (
                AsyncActorRolloutRefWorker
                if config.actor_rollout_ref.rollout.mode == "async"
                else ActorRolloutRefWorker
            )
            ray_worker_group_cls = RayWorkerGroup

        elif config.actor_rollout_ref.actor.strategy == "megatron":
            from verl.workers.megatron_workers import (
                ActorRolloutRefWorker,
                AsyncActorRolloutRefWorker,
            )

            actor_rollout_cls = (
                AsyncActorRolloutRefWorker
                if config.actor_rollout_ref.rollout.mode == "async"
                else ActorRolloutRefWorker
            )
            ray_worker_group_cls = RayWorkerGroup

        else:
            raise NotImplementedError

        from ray_test import Role

        self.role_worker_mapping[Role.ActorRollout] = ray.remote(actor_rollout_cls)

        return actor_rollout_cls, ray_worker_group_cls

    def init_resource_pool_mgr(self, config):
        """Initialize resource pool manager."""
        from ray_test import Role

        global_pool_id = "global_pool"
        resource_pool_spec = {
            global_pool_id: [config.trainer.n_gpus_per_node] * config.trainer.nnodes,
        }
        self.mapping[Role.ActorRollout] = global_pool_id
        self.mapping[Role.Critic] = global_pool_id
        from ray_test import ResourcePoolManager

        resource_pool_manager = ResourcePoolManager(
            resource_pool_spec=resource_pool_spec, mapping=self.mapping
        )
        return resource_pool_manager

    def run(self, config):
        """Execute the main testing workflow.

        This method sets up the distributed testing environment, initializes
        workers, datasets, and reward functions, then starts the testing process.

        Args:
            config: testing configuration object containing all parameters needed
                   for setting up and running the testing process.
        """
        # Print the initial configuration. `resolve=True` will evaluate symbolic values.
        from pprint import pprint

        from omegaconf import OmegaConf

        from verl.utils.fs import copy_to_local

        print(f"TaskRunner hostname: {socket.gethostname()}, PID: {os.getpid()}")
        pprint(OmegaConf.to_container(config, resolve=True))
        OmegaConf.resolve(config)

        # Download the checkpoint from HDFS to the local machine.
        # `use_shm` determines whether to use shared memory, which could lead to faster model loading if turned on
        local_path = copy_to_local(
            config.actor_rollout_ref.model.path,
            use_shm=config.actor_rollout_ref.model.get("use_shm", False),
        )

        # Instantiate the tokenizer and processor.
        from verl.utils import hf_processor, hf_tokenizer

        trust_remote_code = config.data.get("trust_remote_code", False)
        tokenizer = hf_tokenizer(local_path, trust_remote_code=trust_remote_code)
        # Used for multimodal LLM, could be None
        processor = hf_processor(
            local_path, trust_remote_code=trust_remote_code, use_fast=True
        )

        actor_rollout_cls, ray_worker_group_cls = self.add_actor_rollout_worker(config)

        # We should adopt a multi-source reward function here:
        # - for rule-based rm, we directly call a reward score
        # - for model-based rm, we call a model
        # - for code related prompt, we send to a sandbox if there are test cases
        # finally, we combine all the rewards together
        # The reward type depends on the tag of the data

        # Add a reference policy worker if KL loss or KL reward is used.

        from reward.pokee_batch_reward_manager import PokeeBatchRewardManager
        from verl.workers.reward_manager import register as register_reward_manager

        register_reward_manager("pokee_batch")(PokeeBatchRewardManager)
        # Load the reward manager for validation.

        val_reward_fn = load_reward_manager(
            config,
            tokenizer,
            num_examine=0,
            overlong_buffer_len=config.reward_model.overlong_buffer_len,
            max_resp_len=config.data.max_response_length,
            max_num_turns=config.actor_rollout_ref.rollout.multi_turn.max_assistant_turns * 2,
            reward_weights=config.reward_model.get("val_reward_weights", {}),
            **config.reward_model.get("reward_kwargs", {}),
        )

        resource_pool_manager = self.init_resource_pool_mgr(config)

        from verl.utils.dataset.rl_dataset import collate_fn

        val_dataset = create_rl_dataset(
            config.data.val_files, config.data, tokenizer, processor, is_train=False
        )

        tester = RayTest(
            config=config,
            tokenizer=tokenizer,
            processor=processor,
            role_worker_mapping=self.role_worker_mapping,
            resource_pool_manager=resource_pool_manager,
            ray_worker_group_cls=ray_worker_group_cls,
            val_reward_fn=val_reward_fn,
            val_dataset=val_dataset,
            collate_fn=collate_fn,
        )
        # Initialize the workers of the trainer.
        tester.init_workers()
        # Start the training process.
        tester.eval()


def create_rl_dataset(data_paths, data_config, tokenizer, processor, is_train=True):
    """Create a dataset.

    Arguments:
        data_paths: List of paths to data files.
        data_config: The data config.
        tokenizer (Tokenizer): The tokenizer.
        processor (Processor): The processor.

    Returns:
        dataset (Dataset): The dataset.
    """
    from torch.utils.data import Dataset

    from verl.utils.dataset.rl_dataset import RLHFDataset

    # Check if a custom dataset class is specified in the data configuration
    # and if the path to the custom class is provided
    if (
        "custom_cls" in data_config
        and data_config.custom_cls.get("path", None) is not None
    ):
        # Dynamically load the custom dataset class
        dataset_cls = load_extern_type(
            data_config.custom_cls.path, data_config.custom_cls.name
        )
        # Verify that the custom dataset class inherits from torch.utils.data.Dataset
        if not issubclass(dataset_cls, Dataset):
            raise TypeError(
                f"The custom dataset class '{data_config.custom_cls.name}' from "
                f"'{data_config.custom_cls.path}' must inherit from torch.utils.data.Dataset"
            )
    elif (
        "datagen" in data_config
        and data_config.datagen.get("path", None) is not None
        and is_train
    ):
        # If a data generation strategy is specified, use the DynamicGenDataset class
        from verl.experimental.dynamic_dataset.dynamicgen_dataset import DynamicGenDataset

        dataset_cls = DynamicGenDataset
        print("Using DynamicGenDataset for data generation.")

    else:
        # Use the default RLHFDataset class if no custom class is specified
        dataset_cls = RLHFDataset
    print(f"Using dataset class: {dataset_cls.__name__}")

    # Instantiate the dataset using the determined dataset class
    dataset = dataset_cls(
        data_files=data_paths,
        tokenizer=tokenizer,
        processor=processor,
        config=data_config,
    )

    return dataset


if __name__ == "__main__":
    main()
